namespace ext
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// Base class for any {@link Ext.BoxComponent} that may contain other Components. Containers handle the
	/// basic behavior of containing items, namely adding, inserting and removing items.  The most commonly used Container classes are {@link Ext.Panel}, {@link Ext.Window} and {@link Ext.TabPanel}.
	/// If you do not need the capabilities offered by the aforementioned classes you can create a lightweight
	/// Container to be encapsulated by an HTML element to your specifications by using the
	/// {@link Ext.Component#autoEl autoEl} config option. This is a useful technique when creating
	/// embedded {@link Ext.layout.ColumnLayout column} layouts inside {@link Ext.form.FormPanel FormPanels}
	/// for example.  The code below illustrates both how to explicitly create a Container, and how to implicitly
	/// create one using the &apos;container&apos; xtype: 
	/// // explicitly create a Container
	/// var embeddedColumns = new Ext.Container({
	/// autoEl: &apos;div&apos;, // This is the default
	/// layout: &apos;column&apos;,
	/// defaults: {
	/// // implicitly create...
	/// </summary>
	/// <htmlSummary>
	/// &lt;p&gt;Base class for any {@link Ext.BoxComponent} that may contain other Components. Containers handle the
	/// basic behavior of containing items, namely adding, inserting and removing items.&lt;/p&gt;
	///
	/// &lt;p&gt;The most commonly used Container classes are {@link Ext.Panel}, {@link Ext.Window} and {@link Ext.TabPanel}.
	/// If you do not need the capabilities offered by the aforementioned classes you can create a lightweight
	/// Container to be encapsulated by an HTML element to your specifications by using the
	/// &lt;code&gt;&lt;b&gt;{@link Ext.Component#autoEl autoEl}&lt;/b&gt;&lt;/code&gt; config option. This is a useful technique when creating
	/// embedded {@link Ext.layout.ColumnLayout column} layouts inside {@link Ext.form.FormPanel FormPanels}
	/// for example.&lt;/p&gt;
	///
	/// &lt;p&gt;The code below illustrates both how to explicitly create a Container, and how to implicitly
	/// create one using the &lt;b&gt;&lt;code&gt;&apos;container&apos;&lt;/code&gt;&lt;/b&gt; xtype:&lt;pre&gt;&lt;code&gt;
	/// // explicitly create a Container
	/// var embeddedColumns = new Ext.Container({
	/// autoEl: &apos;div&apos;, // This is the default
	/// layout: &apos;column&apos;,
	/// defaults: {
	/// // implicitly create Container by specifying xtype
	/// xtype: &apos;container&apos;,
	/// autoEl: &apos;div&apos;, // This is the default.
	/// layout: &apos;form&apos;,
	/// columnWidth: 0.5,
	/// style: {
	/// padding: &apos;10px&apos;
	/// }
	/// },
	/// // The two items below will be Ext.Containers, each encapsulated by a &amp;lt;DIV&gt; element.
	/// items: [{
	/// items: {
	/// xtype: &apos;datefield&apos;,
	/// name: &apos;startDate&apos;,
	/// fieldLabel: &apos;Start date&apos;
	/// }
	/// }, {
	/// items: {
	/// xtype: &apos;datefield&apos;,
	/// name: &apos;endDate&apos;,
	/// fieldLabel: &apos;End date&apos;
	/// }
	/// }]
	/// });&lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
	///
	/// &lt;p&gt;&lt;u&gt;&lt;b&gt;Layout&lt;/b&gt;&lt;/u&gt;&lt;/p&gt;
	/// &lt;p&gt;Container classes delegate the rendering of child Components to a layout
	/// manager class which must be configured into the Container using the
	/// &lt;code&gt;&lt;b&gt;{@link #layout}&lt;/b&gt;&lt;/code&gt; configuration property.&lt;/p&gt;
	/// &lt;p&gt;When either specifying child &lt;code&gt;{@link #items}&lt;/code&gt; of a Container,
	/// or dynamically {@link #add adding} Components to a Container, remember to
	/// consider how you wish the Container to arrange those child elements, and
	/// whether those child elements need to be sized using one of Ext&apos;s built-in
	/// &lt;b&gt;&lt;code&gt;{@link #layout}&lt;/code&gt;&lt;/b&gt; schemes. By default, Containers use the
	/// {@link Ext.layout.ContainerLayout ContainerLayout} scheme which only
	/// renders child components, appending them one after the other inside the
	/// Container, and &lt;b&gt;does not apply any sizing&lt;/b&gt; at all.&lt;/p&gt;
	/// &lt;p&gt;A common mistake is when a developer neglects to specify a
	/// &lt;b&gt;&lt;code&gt;{@link #layout}&lt;/code&gt;&lt;/b&gt; (e.g. widgets like GridPanels or
	/// TreePanels are added to Containers for which no &lt;code&gt;&lt;b&gt;{@link #layout}&lt;/b&gt;&lt;/code&gt;
	/// has been specified). If a Container is left to use the default
	/// {@link Ext.layout.ContainerLayout ContainerLayout} scheme, none of its
	/// child components will be resized, or changed in any way when the Container
	/// is resized.&lt;/p&gt;
	/// &lt;p&gt;Certain layout managers allow dynamic addition of child components.
	/// Those that do include {@link Ext.layout.CardLayout},
	/// {@link Ext.layout.AnchorLayout}, {@link Ext.layout.FormLayout}, and
	/// {@link Ext.layout.TableLayout}. For example:&lt;pre&gt;&lt;code&gt;
	/// // Create the GridPanel.
	/// var myNewGrid = new Ext.grid.GridPanel({
	/// store: myStore,
	/// columns: myColumnModel,
	/// title: &apos;Results&apos;, // the title becomes the title of the tab
	/// });
	///
	/// myTabPanel.add(myNewGrid); // {@link Ext.TabPanel} implicitly uses {@link Ext.layout.CardLayout CardLayout}
	/// myTabPanel.{@link Ext.TabPanel#setActiveTab setActiveTab}(myNewGrid);
	/// &lt;/code&gt;&lt;/pre&gt;&lt;/p&gt;
	/// &lt;p&gt;The example above adds a newly created GridPanel to a TabPanel. Note that
	/// a TabPanel uses {@link Ext.layout.CardLayout} as its layout manager which
	/// means all its child items are sized to {@link Ext.layout.FitLayout fit}
	/// exactly into its client area.
	/// &lt;p&gt;&lt;b&gt;&lt;u&gt;Overnesting is a common problem&lt;/u&gt;&lt;/b&gt;.
	/// An example of overnesting occurs when a GridPanel is added to a TabPanel
	/// by wrapping the GridPanel &lt;i&gt;inside&lt;/i&gt; a wrapping Panel (that has no
	/// &lt;code&gt;&lt;b&gt;{@link #layout}&lt;/b&gt;&lt;/code&gt; specified) and then add that wrapping Panel
	/// to the TabPanel. The point to realize is that a GridPanel &lt;b&gt;is&lt;/b&gt; a
	/// Component which can be added directly to a Container. If the wrapping Panel
	/// has no &lt;code&gt;&lt;b&gt;{@link #layout}&lt;/b&gt;&lt;/code&gt; configuration, then the overnested
	/// GridPanel will not be sized as expected.&lt;p&gt;
	///
	/// &lt;p&gt;&lt;u&gt;&lt;b&gt;Adding via remote configuration&lt;/b&gt;&lt;/u&gt;&lt;/p&gt;
	///
	/// &lt;p&gt;A server side script can be used to add Components which are generated dynamically on the server.
	/// An example of adding a GridPanel to a TabPanel where the GridPanel is generated by the server
	/// based on certain parameters:
	/// &lt;/p&gt;&lt;pre&gt;&lt;code&gt;
	/// // execute an Ajax request to invoke server side script:
	/// Ext.Ajax.request({
	/// url: &apos;gen-invoice-grid.php&apos;,
	/// // send additional parameters to instruct server script
	/// params: {
	/// startDate: Ext.getCmp(&apos;start-date&apos;).getValue(),
	/// endDate: Ext.getCmp(&apos;end-date&apos;).getValue()
	/// },
	/// // process the response object to add it to the TabPanel:
	/// success: function(xhr) {
	/// var newComponent = eval(xhr.responseText); // see discussion below
	/// myTabPanel.add(newComponent); // add the component to the TabPanel
	/// myTabPanel.setActiveTab(newComponent);
	/// },
	/// failure: function() {
	/// Ext.Msg.alert(&quot;Grid create failed&quot;, &quot;Server communication failure&quot;);
	/// }
	/// });
	/// &lt;/code&gt;&lt;/pre&gt;
	/// &lt;p&gt;The server script needs to return an executable Javascript statement which, when processed
	/// using &lt;code&gt;eval()&lt;/code&gt;, will return either a config object with an {@link Ext.Component#xtype xtype},
	/// or an instantiated Component. The server might return this for example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
	/// (function() {
	/// function formatDate(value){
	/// return value ? value.dateFormat(&apos;M d, Y&apos;) : &apos;&apos;;
	/// };
	///
	/// var store = new Ext.data.Store({
	/// url: &apos;get-invoice-data.php&apos;,
	/// baseParams: {
	/// startDate: &apos;01/01/2008&apos;,
	/// endDate: &apos;01/31/2008&apos;
	/// },
	/// reader: new Ext.data.JsonReader({
	/// record: &apos;transaction&apos;,
	/// idProperty: &apos;id&apos;,
	/// totalRecords: &apos;total&apos;
	/// }, [
	/// &apos;customer&apos;,
	/// &apos;invNo&apos;,
	/// {name: &apos;date&apos;, type: &apos;date&apos;, dateFormat: &apos;m/d/Y&apos;},
	/// {name: &apos;value&apos;, type: &apos;float&apos;}
	/// ])
	/// });
	///
	/// var grid = new Ext.grid.GridPanel({
	/// title: &apos;Invoice Report&apos;,
	/// bbar: new Ext.PagingToolbar(store),
	/// store: store,
	/// columns: [
	/// {header: &quot;Customer&quot;, width: 250, dataIndex: &apos;customer&apos;, sortable: true},
	/// {header: &quot;Invoice Number&quot;, width: 120, dataIndex: &apos;invNo&apos;, sortable: true},
	/// {header: &quot;Invoice Date&quot;, width: 100, dataIndex: &apos;date&apos;, renderer: formatDate, sortable: true},
	/// {header: &quot;Value&quot;, width: 120, dataIndex: &apos;value&apos;, renderer: &apos;usMoney&apos;, sortable: true}
	/// ],
	/// });
	/// store.load();
	/// return grid; // return instantiated component
	/// })();
	/// &lt;/code&gt;&lt;/pre&gt;
	/// &lt;p&gt;When the above code fragment is passed through the &lt;code&gt;eval&lt;/code&gt; function in the success handler
	/// of the Ajax request, the code is executed by the Javascript processor, and the anonymous function
	/// runs, and returns the instantiated grid component.&lt;/p&gt;
	/// &lt;p&gt;Note: since the code above is &lt;i&gt;generated&lt;/i&gt; by a server script, the &lt;code&gt;baseParams&lt;/code&gt; for
	/// the Store, the metadata to allow generation of the Record layout, and the ColumnModel
	/// can all be generated into the code since these are all known on the server.&lt;/p&gt;
	/// </htmlSummary>
	/// <definedin>src\widgets\Container.js</definedin>
	[ScriptName("Container")]
	[ScriptNamespace("Ext")]
	[Imported()]
	public partial class Container : ext.BoxComponent
	{
		
		#region Constructors
		public Container(ext.Container_Configuration config)
		{
		}
		
		/// <summary>Constructor</summary>
		public Container()
		{
		}
		#endregion
		
		#region Fields
		/// <summary>
		/// True to automatically monitor window resize events to handle anything that is sensitive to the current size
		/// of the viewport. This value is typically managed by the chosen {@link #layout} and should not need
		/// to be set manually.
		/// </summary>
		/// <htmlSummary>
		/// True to automatically monitor window resize events to handle anything that is sensitive to the current size
		/// of the viewport. This value is typically managed by the chosen &lt;code&gt;{@link #layout}&lt;/code&gt; and should not need
		/// to be set manually.
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("monitorResize")]
		public bool MonitorResize;
		
		/// <summary>
		/// *Important: In order for child items to be correctly sized and
		/// positioned, typically a layout manager must be specified through
		/// the layout configuration option.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;&lt;b&gt;*Important&lt;/b&gt;: In order for child items to be correctly sized and
		/// positioned, typically a layout manager &lt;b&gt;must&lt;/b&gt; be specified through
		/// the &lt;code&gt;layout&lt;/code&gt; configuration option.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;The sizing and positioning of child {@link items} is the responsibility of
		/// the Container&apos;s layout manager which creates and manages the type of layout
		/// you have in mind. For example:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// new Ext.Window({
		/// width:300, height: 300,
		/// layout: &apos;fit&apos;, // explicitly set layout manager: override the default (layout:&apos;auto&apos;)
		/// items: [{
		/// title: &apos;Panel inside a Window&apos;
		/// }]
		/// }).show();
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;If the {@link #layout} configuration is not explicitly specified for
		/// a general purpose container (e.g. Container or Panel) the
		/// {@link Ext.layout.ContainerLayout default layout manager} will be used
		/// which does nothing but render child components sequentially into the
		/// Container (no sizing or positioning will be performed in this situation).
		/// Some container classes implicitly specify a default layout
		/// (e.g. FormPanel specifies &lt;code&gt;layout:&apos;form&apos;&lt;/code&gt;). Other specific
		/// purpose classes internally specify/manage their internal layout (e.g.
		/// GridPanel, TabPanel, TreePanel, Toolbar, Menu, etc.).&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;&lt;code&gt;layout&lt;/code&gt;&lt;/b&gt; may be specified as either as an Object or
		/// as a String:&lt;/p&gt;&lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		///
		/// &lt;li&gt;&lt;u&gt;Specify as an Object&lt;/u&gt;&lt;/li&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;Example usage:&lt;/li&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// layout: {
		/// type: &apos;vbox&apos;,
		/// padding: &apos;5&apos;,
		/// align: &apos;left&apos;
		/// }
		/// &lt;/code&gt;&lt;/pre&gt;
		///
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;type&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;br/&gt;&lt;p&gt;The layout type to be used for this container. If not specified,
		/// a default {@link Ext.layout.ContainerLayout} will be created and used.&lt;/p&gt;
		/// &lt;br/&gt;&lt;p&gt;Valid layout &lt;code&gt;type&lt;/code&gt; values are:&lt;/p&gt;
		/// &lt;div class=&quot;sub-desc&quot;&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.AbsoluteLayout absolute}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.AccordionLayout accordion}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.AnchorLayout anchor}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.ContainerLayout auto}&lt;/b&gt;&lt;/code&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp; &lt;b&gt;Default&lt;/b&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.BorderLayout border}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.CardLayout card}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.ColumnLayout column}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.FitLayout fit}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.FormLayout form}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.HBoxLayout hbox}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.MenuLayout menu}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.TableLayout table}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.ToolbarLayout toolbar}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link Ext.layout.VBoxLayout vbox}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;li&gt;Layout specific configuration properties&lt;/li&gt;
		/// &lt;br/&gt;&lt;p&gt;Additional layout specific configuration properties may also be
		/// specified. For complete details regarding the valid config options for
		/// each layout type, see the layout class corresponding to the &lt;code&gt;type&lt;/code&gt;
		/// specified.&lt;/p&gt;
		///
		/// &lt;/ul&gt;&lt;/div&gt;
		///
		/// &lt;li&gt;&lt;u&gt;Specify as a String&lt;/u&gt;&lt;/li&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;Example usage:&lt;/li&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// layout: &apos;vbox&apos;,
		/// layoutConfig: {
		/// padding: &apos;5&apos;,
		/// align: &apos;left&apos;
		/// }
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;layout&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;br/&gt;&lt;p&gt;The layout &lt;code&gt;type&lt;/code&gt; to be used for this container (see list
		/// of valid layout type values above).&lt;/p&gt;&lt;br/&gt;
		/// &lt;li&gt;&lt;code&gt;&lt;b&gt;{@link #layoutConfig}&lt;/b&gt;&lt;/code&gt;&lt;/li&gt;
		/// &lt;br/&gt;&lt;p&gt;Additional layout specific configuration properties. For complete
		/// details regarding the valid config options for each layout type, see the
		/// layout class corresponding to the &lt;code&gt;layout&lt;/code&gt; specified.&lt;/p&gt;
		/// &lt;/ul&gt;&lt;/div&gt;&lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("layout")]
		public ext.auto.System_String_Or_System_Object Layout;
		
		/// <summary>
		/// This is a config object containing properties specific to the chosen
		/// {@link #layout} if {@link #layout}
		/// has been specified as a string.
		/// </summary>
		/// <htmlSummary>
		/// This is a config object containing properties specific to the chosen
		/// &lt;b&gt;&lt;code&gt;{@link #layout}&lt;/code&gt;&lt;/b&gt; if &lt;b&gt;&lt;code&gt;{@link #layout}&lt;/code&gt;&lt;/b&gt;
		/// has been specified as a &lt;i&gt;string&lt;/i&gt;.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("layoutConfig")]
		public object LayoutConfig;
		
		/// <summary>
		/// When set to true (50 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer
		/// the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers
		/// with a large quantity of sub-components for which frequent layout calls would be expensive. Defaults to 50.
		/// </summary>
		/// <htmlSummary>
		/// When set to true (50 milliseconds) or a number of milliseconds, the layout assigned for this container will buffer
		/// the frequency it calculates and does a re-layout of components. This is useful for heavy containers or containers
		/// with a large quantity of sub-components for which frequent layout calls would be expensive. Defaults to &lt;code&gt;50&lt;/code&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("bufferResize")]
		public ext.auto.System_Boolean_Or_System_Number BufferResize;
		
		/// <summary>
		/// A string component id or the numeric index of the component that should be initially activated within the
		/// container&apos;s layout on render. For example, activeItem: &apos;item-1&apos; or activeItem: 0 (index 0 = the first
		/// item in the container&apos;s collection). activeItem only applies to layout styles that can display
		/// items one at a time (like {@link Ext.layout.AccordionLayout}, {@link Ext.layout.CardLayout} and
		/// {@link Ext.layout.FitLayout}). Related to {@link Ext.layout.ContainerLayout#activeItem}.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("activeItem")]
		public ext.auto.System_String_Or_System_Number ActiveItem;
		
		/// <summary>
		/// ** IMPORTANT: be sure to {@link #layout specify a layout} if needed ! **  A single item, or an array of child Components to be added to this container,
		/// for example:  
		/// // specifying a single item
		/// items: {...},
		/// layout: &apos;fit&apos;, // specify a layout!
		///
		/// // specifying multiple items
		/// items: [{...}, {...}],
		/// layout: &apos;anchor&apos;, // specify a layout!
		///  Each item may be:    any type of object based on {@link Ext.Component}  a fully instanciated object or  an object literal that:    has a specified {@link Ext.Component#xtype xtype}  the {@link Ext.Component#xtype} specified is associated with the Component
		/// desired and should be chosen from one of the available xtypes as listed
		/// in {@link Ext.Component}.  If an {@link Ext.Component#xtype xtype} is not explicitly
		/// specified, the {@link #defaultType} for that Container is used.  will be &quot;lazily instanciated&quot;, avoiding the overhead of constructing a fully
		/// instanciated Component object      Notes:    Ext uses lazy rendering. Child Components...
		/// </summary>
		/// <htmlSummary>
		/// &lt;pre&gt;&lt;b&gt;** IMPORTANT&lt;/b&gt;: be sure to &lt;b&gt;{@link #layout specify a &lt;code&gt;layout&lt;/code&gt;} if needed ! **&lt;/b&gt;&lt;/pre&gt;
		/// &lt;p&gt;A single item, or an array of child Components to be added to this container,
		/// for example:&lt;/p&gt;
		/// &lt;pre&gt;&lt;code&gt;
		/// // specifying a single item
		/// items: {...},
		/// layout: &apos;fit&apos;, // specify a layout!
		///
		/// // specifying multiple items
		/// items: [{...}, {...}],
		/// layout: &apos;anchor&apos;, // specify a layout!
		/// &lt;/code&gt;&lt;/pre&gt;
		/// &lt;p&gt;Each item may be:&lt;/p&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;any type of object based on {@link Ext.Component}&lt;/li&gt;
		/// &lt;li&gt;a fully instanciated object or&lt;/li&gt;
		/// &lt;li&gt;an object literal that:&lt;/li&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;has a specified &lt;code&gt;{@link Ext.Component#xtype xtype}&lt;/code&gt;&lt;/li&gt;
		/// &lt;li&gt;the {@link Ext.Component#xtype} specified is associated with the Component
		/// desired and should be chosen from one of the available xtypes as listed
		/// in {@link Ext.Component}.&lt;/li&gt;
		/// &lt;li&gt;If an &lt;code&gt;{@link Ext.Component#xtype xtype}&lt;/code&gt; is not explicitly
		/// specified, the {@link #defaultType} for that Container is used.&lt;/li&gt;
		/// &lt;li&gt;will be &quot;lazily instanciated&quot;, avoiding the overhead of constructing a fully
		/// instanciated Component object&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;&lt;/ul&gt;&lt;/div&gt;
		/// &lt;p&gt;&lt;b&gt;Notes&lt;/b&gt;:&lt;/p&gt;
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;Ext uses lazy rendering. Child Components will only be rendered
		/// should it become necessary. Items are automatically laid out when they are first
		/// shown (no sizing is done while hidden), or in response to a {@link #doLayout} call.&lt;/li&gt;
		/// &lt;li&gt;Do not specify &lt;code&gt;{@link Ext.Panel#contentEl contentEl}&lt;/code&gt;/
		/// &lt;code&gt;{@link Ext.Panel#html html}&lt;/code&gt; with &lt;code&gt;items&lt;/code&gt;.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("items")]
		public ext.auto.System_Object_Or_System_Array Items;
		
		/// <summary>
		/// This option is a means of applying default settings to all added items whether added through the {@link #items}
		/// config or via the {@link #add} or {@link #insert} methods.  If an added item is a config object, and not an instantiated Component, then the default properties are
		/// unconditionally applied. If the added item is an instantiated Component, then the default properties are
		/// applied conditionally so as not to override existing properties in the item.  If the defaults option is specified as a function, then the function will be called using this Container as the
		/// scope (this reference) and passing the added item as the first parameter. Any resulting object
		/// from that call is then applied to the item as default properties.  For example, to automatically apply padding to the body of each of a set of
		/// contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:&apos;padding:15px&apos;}.  Usage:  
		/// defaults: { // defaults are applied to items, not the container
		/// ..
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;This option is a means of applying default settings to all added items whether added through the {@link #items}
		/// config or via the {@link #add} or {@link #insert} methods.&lt;/p&gt;
		/// &lt;p&gt;If an added item is a config object, and &lt;b&gt;not&lt;/b&gt; an instantiated Component, then the default properties are
		/// unconditionally applied. If the added item &lt;b&gt;is&lt;/b&gt; an instantiated Component, then the default properties are
		/// applied conditionally so as not to override existing properties in the item.&lt;/p&gt;
		/// &lt;p&gt;If the defaults option is specified as a function, then the function will be called using this Container as the
		/// scope (&lt;code&gt;this&lt;/code&gt; reference) and passing the added item as the first parameter. Any resulting object
		/// from that call is then applied to the item as default properties.&lt;/p&gt;
		/// &lt;p&gt;For example, to automatically apply padding to the body of each of a set of
		/// contained {@link Ext.Panel} items, you could pass: &lt;code&gt;defaults: {bodyStyle:&apos;padding:15px&apos;}&lt;/code&gt;.&lt;/p&gt;
		/// &lt;p&gt;Usage:&lt;/p&gt;&lt;pre&gt;&lt;code&gt;
		/// defaults: { // defaults are applied to items, not the container
		/// autoScroll:true
		/// },
		/// items: [
		/// {
		/// xtype: &apos;panel&apos;, // defaults &lt;b&gt;do not&lt;/b&gt; have precedence over
		/// id: &apos;panel1&apos;, // options in config objects, so the defaults
		/// autoScroll: false // will not be applied here, panel1 will be autoScroll:false
		/// },
		/// new Ext.Panel({ // defaults &lt;b&gt;do&lt;/b&gt; have precedence over options
		/// id: &apos;panel2&apos;, // options in components, so the defaults
		/// autoScroll: false // will be applied here, panel2 will be autoScroll:true.
		/// })
		/// ]
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("defaults")]
		public ext.auto.System_Object_Or_System_Delegate Defaults;
		
		/// <summary>
		/// If true the container will automatically destroy any contained component that is removed from it, else
		/// destruction must be handled manually (defaults to true).
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("autoDestroy")]
		public bool AutoDestroy;
		
		/// <summary>
		/// If true the container will force a layout initially even if hidden or collapsed. This option
		/// is useful for forcing forms to render in collapsed or hidden containers. (defaults to false).
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("forceLayout")]
		public bool ForceLayout;
		
		/// <summary>
		/// True to hide the borders of each contained component, false to defer to the component&apos;s existing
		/// border settings (defaults to false).
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("hideBorders")]
		public bool HideBorders;
		
		/// <summary>
		/// The default {@link Ext.Component xtype} of child Components to create in this Container when
		/// a child item is specified as a raw configuration object, rather than as an instantiated Component.  Defaults to &apos;panel&apos;, except {@link Ext.menu.Menu} which defaults to &apos;menuitem&apos;,
		/// and {@link Ext.Toolbar} and {@link Ext.ButtonGroup} which default to &apos;button&apos;.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;The default {@link Ext.Component xtype} of child Components to create in this Container when
		/// a child item is specified as a raw configuration object, rather than as an instantiated Component.&lt;/p&gt;
		/// &lt;p&gt;Defaults to &lt;code&gt;&apos;panel&apos;&lt;/code&gt;, except {@link Ext.menu.Menu} which defaults to &lt;code&gt;&apos;menuitem&apos;&lt;/code&gt;,
		/// and {@link Ext.Toolbar} and {@link Ext.ButtonGroup} which default to &lt;code&gt;&apos;button&apos;&lt;/code&gt;.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("defaultType")]
		public string DefaultType;
		
		/// <summary>The event to listen to for resizing in layouts. Defaults to &apos;resize&apos;.</summary>
		/// <htmlSummary>The event to listen to for resizing in layouts. Defaults to &lt;code&gt;&apos;resize&apos;&lt;/code&gt;.</htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("resizeEvent")]
		public string ResizeEvent;
		
		/// <summary>
		/// An array of events that, when fired, should be bubbled to any parent container.
		/// See {@link Ext.util.Observable#enableBubble}.
		/// Defaults to [&apos;add&apos;, &apos;remove&apos;].
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;An array of events that, when fired, should be bubbled to any parent container.
		/// See {@link Ext.util.Observable#enableBubble}.
		/// Defaults to &lt;code&gt;[&apos;add&apos;, &apos;remove&apos;]&lt;/code&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("bubbleEvents")]
		public System.Array BubbleEvents;
		
		/// <summary>Fires when the components in this container are arranged by the associated layout manager.</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("afterlayoutEventName")]
		public const string AfterlayoutEventName = "afterlayout";
		
		/// <summary>
		/// Fires before any {@link Ext.Component} is added or inserted into the container.
		/// A handler can return false to cancel the add.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("beforeaddEventName")]
		public const string BeforeaddEventName = "beforeadd";
		
		/// <summary>
		/// Fires before any {@link Ext.Component} is removed from the container. A handler can return
		/// false to cancel the remove.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("beforeremoveEventName")]
		public const string BeforeremoveEventName = "beforeremove";
		
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("addEventName")]
		public const string AddEventName = "add";
		
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("removeEventName")]
		public const string RemoveEventName = "remove";
		#endregion
		
		#region Properties
		/// <summary>The collection of components in this container as a {@link Ext.util.MixedCollection}</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("items")]
		[IntrinsicProperty()]
		public System.Array ItemsProperty
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>
		/// Returns the Element to be used to contain the child Components of this Container.  An implementation is provided which returns the Container&apos;s {@link #getEl Element}, but
		/// if there is a more complex structure to a Container, this may be overridden to return
		/// the element into which the {@link #layout layout} renders child Components.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Returns the Element to be used to contain the child Components of this Container.&lt;/p&gt;
		/// &lt;p&gt;An implementation is provided which returns the Container&apos;s {@link #getEl Element}, but
		/// if there is a more complex structure to a Container, this may be overridden to return
		/// the element into which the {@link #layout layout} renders child Components.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <returns>The Element to render child Components into.</returns>
		[ScriptName("getLayoutTarget")]
		public ext.Element GetLayoutTarget()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Inserts a Component into this Container at a specified index. Fires the
		/// {@link #beforeadd} event before inserting, then fires the {@link #add} event after the
		/// Component has been inserted.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="index">
		/// The index at which the Component will be inserted
		/// into the Container&apos;s items collection
		/// </param>
		/// <param name="component">
		/// The child Component to insert.&lt;br&gt;&lt;br&gt;
		/// Ext uses lazy rendering, and will only render the inserted Component should
		/// it become necessary.&lt;br&gt;&lt;br&gt;
		/// A Component config object may be passed in order to avoid the overhead of
		/// constructing a real Component object if lazy rendering might mean that the
		/// inserted Component will not be rendered immediately. To take advantage of
		/// this &apos;lazy instantiation&apos;, set the {@link Ext.Component#xtype} config
		/// property to the registered type of the Component wanted.&lt;br&gt;&lt;br&gt;
		/// For a list of all available xtypes, see {@link Ext.Component}.
		/// </param>
		/// <returns>
		/// component The Component (or config object) that was
		/// inserted with the Container&apos;s default config values applied.
		/// </returns>
		[ScriptName("insert")]
		public ext.Component Insert(System.Number index, ext.Component component)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the layout currently in use by the container. If the container does not currently have a layout
		/// set, a default {@link Ext.layout.ContainerLayout} will be created and set as the container&apos;s layout.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <returns>layout The container&apos;s layout</returns>
		[ScriptName("getLayout")]
		public ext.layout.ContainerLayout GetLayout()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a component under this container at any level by id</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="id"></param>
		[ScriptName("findById")]
		public ext.Component FindById(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a component under this container at any level by property</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="prop"></param>
		/// <param name="value"></param>
		/// <returns>Array of Ext.Components</returns>
		[ScriptName("find")]
		public System.Array Find(string prop, string value)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds {@link Ext.Component Component}(s) to this Container.</summary>
		/// <htmlSummary>
		/// &lt;p&gt;Adds {@link Ext.Component Component}(s) to this Container.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt; :
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;Fires the {@link #beforeadd} event before adding&lt;/li&gt;
		/// &lt;li&gt;The Container&apos;s {@link #defaults default config values} will be applied
		/// accordingly (see &lt;code&gt;{@link #defaults}&lt;/code&gt; for details).&lt;/li&gt;
		/// &lt;li&gt;Fires the {@link #add} event after the component has been added.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Notes&lt;/b&gt;&lt;/u&gt; :
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;If the Container is &lt;i&gt;already rendered&lt;/i&gt; when &lt;code&gt;add&lt;/code&gt;
		/// is called, you may need to call {@link #doLayout} to refresh the view which causes
		/// any unrendered child Components to be rendered. This is required so that you can
		/// &lt;code&gt;add&lt;/code&gt; multiple child components if needed while only refreshing the layout
		/// once. For example:&lt;pre&gt;&lt;code&gt;
		/// var tb = new {@link Ext.Toolbar}();
		/// tb.render(document.body); // toolbar is rendered
		/// tb.add({text:&apos;Button 1&apos;}); // add multiple items ({@link #defaultType} for {@link Ext.Toolbar Toolbar} is &apos;button&apos;)
		/// tb.add({text:&apos;Button 2&apos;});
		/// tb.{@link #doLayout}(); // refresh the layout
		/// &lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;i&gt;Warning:&lt;/i&gt; Containers directly managed by the BorderLayout layout manager
		/// may not be removed or added. See the Notes for {@link Ext.layout.BorderLayout BorderLayout}
		/// for more details.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="component">
		/// &lt;p&gt;Either one or more Components to add or an Array of Components to add. See
		/// <c>{@link #items}</c> for additional information.&lt;/p&gt;
		/// </param>
		/// <returns>The Components that were added.</returns>
		[ScriptName("add")]
		public ext.auto.ext_Component_Or_System_Array AddMethod(object component)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Adds {@link Ext.Component Component}(s) to this Container.</summary>
		/// <htmlSummary>
		/// &lt;p&gt;Adds {@link Ext.Component Component}(s) to this Container.&lt;/p&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt; :
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;Fires the {@link #beforeadd} event before adding&lt;/li&gt;
		/// &lt;li&gt;The Container&apos;s {@link #defaults default config values} will be applied
		/// accordingly (see &lt;code&gt;{@link #defaults}&lt;/code&gt; for details).&lt;/li&gt;
		/// &lt;li&gt;Fires the {@link #add} event after the component has been added.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// &lt;br&gt;&lt;p&gt;&lt;b&gt;Notes&lt;/b&gt;&lt;/u&gt; :
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;If the Container is &lt;i&gt;already rendered&lt;/i&gt; when &lt;code&gt;add&lt;/code&gt;
		/// is called, you may need to call {@link #doLayout} to refresh the view which causes
		/// any unrendered child Components to be rendered. This is required so that you can
		/// &lt;code&gt;add&lt;/code&gt; multiple child components if needed while only refreshing the layout
		/// once. For example:&lt;pre&gt;&lt;code&gt;
		/// var tb = new {@link Ext.Toolbar}();
		/// tb.render(document.body); // toolbar is rendered
		/// tb.add({text:&apos;Button 1&apos;}); // add multiple items ({@link #defaultType} for {@link Ext.Toolbar Toolbar} is &apos;button&apos;)
		/// tb.add({text:&apos;Button 2&apos;});
		/// tb.{@link #doLayout}(); // refresh the layout
		/// &lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;i&gt;Warning:&lt;/i&gt; Containers directly managed by the BorderLayout layout manager
		/// may not be removed or added. See the Notes for {@link Ext.layout.BorderLayout BorderLayout}
		/// for more details.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="component">
		/// &lt;p&gt;Either one or more Components to add or an Array of Components to add. See
		/// <c>{@link #items}</c> for additional information.&lt;/p&gt;
		/// </param>
		/// <returns>The Components that were added.</returns>
		[ScriptName("add")]
		public ext.auto.ext_Component_Or_System_Array AddMethod(System.Array component)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes a component from this container. Fires the {@link #beforeremove} event before removing, then fires
		/// the {@link #remove} event after the component has been removed.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="component">The component reference or id to remove.</param>
		/// <param name="autoDestroy">
		/// True to automatically invoke the removed Component&apos;s {@link Ext.Component#destroy} function.
		/// Defaults to the value of this Container&apos;s {@link #autoDestroy} config.
		/// </param>
		/// <returns>component The Component that was removed.</returns>
		[ScriptName("remove")]
		public ext.Component RemoveMethod(ext.Component component, bool autoDestroy)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes a component from this container. Fires the {@link #beforeremove} event before removing, then fires
		/// the {@link #remove} event after the component has been removed.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="component">The component reference or id to remove.</param>
		/// <param name="autoDestroy">
		/// True to automatically invoke the removed Component&apos;s {@link Ext.Component#destroy} function.
		/// Defaults to the value of this Container&apos;s {@link #autoDestroy} config.
		/// </param>
		/// <returns>component The Component that was removed.</returns>
		[ScriptName("remove")]
		public ext.Component RemoveMethod(string component, bool autoDestroy)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes a component from this container. Fires the {@link #beforeremove} event before removing, then fires
		/// the {@link #remove} event after the component has been removed.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="component">The component reference or id to remove.</param>
		/// <returns>component The Component that was removed.</returns>
		[ScriptName("remove")]
		public ext.Component RemoveMethod(ext.Component component)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Removes a component from this container. Fires the {@link #beforeremove} event before removing, then fires
		/// the {@link #remove} event after the component has been removed.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="component">The component reference or id to remove.</param>
		/// <returns>component The Component that was removed.</returns>
		[ScriptName("remove")]
		public ext.Component RemoveMethod(string component)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes all components from this container.</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="autoDestroy">
		/// True to automatically invoke the removed Component&apos;s {@link Ext.Component#destroy} function.
		/// Defaults to the value of this Container&apos;s {@link #autoDestroy} config.
		/// </param>
		/// <returns>Array of the destroyed components</returns>
		[ScriptName("removeAll")]
		public System.Array RemoveAll(bool autoDestroy)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes all components from this container.</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <returns>Array of the destroyed components</returns>
		[ScriptName("removeAll")]
		public System.Array RemoveAll()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Examines this container&apos;s {@link #items}property
		/// and gets a direct child component of this container.
		/// </summary>
		/// <htmlSummary>
		/// Examines this container&apos;s &lt;code&gt;{@link #items}&lt;/code&gt; &lt;b&gt;property&lt;/b&gt;
		/// and gets a direct child component of this container.
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="comp">
		/// This parameter may be any of the following:
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;a &lt;b&gt;<c>String</c>&lt;/b&gt; : representing the <c>{@link Ext.Component#itemId itemId}</c>
		/// or <c>{@link Ext.Component#id id}</c> of the child component &lt;/li&gt;
		/// &lt;li&gt;a &lt;b&gt;<c>Number</c>&lt;/b&gt; : representing the position of the child component
		/// within the <c>{@link #items}</c> &lt;b&gt;property&lt;/b&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// &lt;p&gt;For additional information see {@link Ext.util.MixedCollection#get}.
		/// </param>
		/// <returns>The component (if found).</returns>
		[ScriptName("getComponent")]
		public ext.Component GetComponent(string comp)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Examines this container&apos;s {@link #items}property
		/// and gets a direct child component of this container.
		/// </summary>
		/// <htmlSummary>
		/// Examines this container&apos;s &lt;code&gt;{@link #items}&lt;/code&gt; &lt;b&gt;property&lt;/b&gt;
		/// and gets a direct child component of this container.
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="comp">
		/// This parameter may be any of the following:
		/// &lt;div&gt;&lt;ul class=&quot;mdetail-params&quot;&gt;
		/// &lt;li&gt;a &lt;b&gt;<c>String</c>&lt;/b&gt; : representing the <c>{@link Ext.Component#itemId itemId}</c>
		/// or <c>{@link Ext.Component#id id}</c> of the child component &lt;/li&gt;
		/// &lt;li&gt;a &lt;b&gt;<c>Number</c>&lt;/b&gt; : representing the position of the child component
		/// within the <c>{@link #items}</c> &lt;b&gt;property&lt;/b&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// &lt;p&gt;For additional information see {@link Ext.util.MixedCollection#get}.
		/// </param>
		/// <returns>The component (if found).</returns>
		[ScriptName("getComponent")]
		public ext.Component GetComponent(System.Number comp)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Cascades down the component/container heirarchy from this component (called first), calling the specified function with
		/// each component. The scope (this) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the cascade is stopped on that branch.
		/// </summary>
		/// <htmlSummary>
		/// Cascades down the component/container heirarchy from this component (called first), calling the specified function with
		/// each component. The scope (&lt;i&gt;this&lt;/i&gt;) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the cascade is stopped on that branch.
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="fn">The function to call</param>
		/// <param name="scope">The scope of the function (defaults to current component)</param>
		/// <param name="args">The args to call the function with (defaults to passing the current component)</param>
		/// <returns>this</returns>
		[ScriptName("cascade")]
		public ext.Container Cascade(System.Delegate fn, object scope, System.Array args)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Cascades down the component/container heirarchy from this component (called first), calling the specified function with
		/// each component. The scope (this) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the cascade is stopped on that branch.
		/// </summary>
		/// <htmlSummary>
		/// Cascades down the component/container heirarchy from this component (called first), calling the specified function with
		/// each component. The scope (&lt;i&gt;this&lt;/i&gt;) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the cascade is stopped on that branch.
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="fn">The function to call</param>
		/// <param name="scope">The scope of the function (defaults to current component)</param>
		/// <returns>this</returns>
		[ScriptName("cascade")]
		public ext.Container Cascade(System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Cascades down the component/container heirarchy from this component (called first), calling the specified function with
		/// each component. The scope (this) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the cascade is stopped on that branch.
		/// </summary>
		/// <htmlSummary>
		/// Cascades down the component/container heirarchy from this component (called first), calling the specified function with
		/// each component. The scope (&lt;i&gt;this&lt;/i&gt;) of
		/// function call will be the scope provided or the current component. The arguments to the function
		/// will be the args provided or the current component. If the function returns false at any point,
		/// the cascade is stopped on that branch.
		/// </htmlSummary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="fn">The function to call</param>
		/// <returns>this</returns>
		[ScriptName("cascade")]
		public ext.Container Cascade(System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a component under this container at any level by xtype or class</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="xtype">The xtype string for a component, or the class of the component directly</param>
		/// <param name="shallow">
		/// False to check whether this Component is descended from the xtype (this is
		/// the default), or true to check whether this Component is directly of the specified xtype.
		/// </param>
		/// <returns>Array of Ext.Components</returns>
		[ScriptName("findByType")]
		public System.Array FindByType(string xtype, bool shallow)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a component under this container at any level by xtype or class</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="xtype">The xtype string for a component, or the class of the component directly</param>
		/// <param name="shallow">
		/// False to check whether this Component is descended from the xtype (this is
		/// the default), or true to check whether this Component is directly of the specified xtype.
		/// </param>
		/// <returns>Array of Ext.Components</returns>
		[ScriptName("findByType")]
		public System.Array FindByType(System.Type xtype, bool shallow)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a component under this container at any level by xtype or class</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="xtype">The xtype string for a component, or the class of the component directly</param>
		/// <returns>Array of Ext.Components</returns>
		[ScriptName("findByType")]
		public System.Array FindByType(string xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Find a component under this container at any level by xtype or class</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="xtype">The xtype string for a component, or the class of the component directly</param>
		/// <returns>Array of Ext.Components</returns>
		[ScriptName("findByType")]
		public System.Array FindByType(System.Type xtype)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Find a component under this container at any level by a custom function. If the passed function returns
		/// true, the component will be included in the results. The passed function is called with the arguments (component, this container).
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="fn">The function to call</param>
		/// <param name="scope"></param>
		/// <returns>Array of Ext.Components</returns>
		[ScriptName("findBy")]
		public System.Array FindBy(System.Delegate fn, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Find a component under this container at any level by a custom function. If the passed function returns
		/// true, the component will be included in the results. The passed function is called with the arguments (component, this container).
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <param name="fn">The function to call</param>
		/// <returns>Array of Ext.Components</returns>
		[ScriptName("findBy")]
		public System.Array FindBy(System.Delegate fn)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get a component contained by this container (alias for items.get(key))</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="key">The index or id of the component</param>
		/// <returns>Ext.Component</returns>
		[ScriptName("get")]
		public ext.Component Get(string key)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Get a component contained by this container (alias for items.get(key))</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="key">The index or id of the component</param>
		/// <returns>Ext.Component</returns>
		[ScriptName("get")]
		public ext.Component Get(System.Number key)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
		
		#region Events
		/// <summary>Fires when the components in this container are arranged by the associated layout manager.</summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("afterlayout")]
		public event ext.auto.Delegate_ext_Container_And_ext_layout_ContainerLayout Afterlayout;
		
		/// <summary>
		/// Fires before any {@link Ext.Component} is added or inserted into the container.
		/// A handler can return false to cancel the add.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("beforeadd")]
		public event ext.auto.Delegate_ext_Container_And_ext_Component_And_System_Number Beforeadd;
		
		/// <summary>
		/// Fires before any {@link Ext.Component} is removed from the container. A handler can return
		/// false to cancel the remove.
		/// </summary>
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("beforeremove")]
		public event ext.auto.Delegate_ext_Container_And_ext_Component Beforeremove;
		
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("add")]
		public event ext.auto.Delegate_ext_Container_And_ext_Component_And_System_Number Add;
		
		/// <definedin>src\widgets\Container.js</definedin>
		[ScriptName("remove")]
		public event ext.auto.Delegate_ext_Container_And_ext_Component Remove;
		#endregion
	}
}
